﻿#region Using directives

using System;
using System.Collections.Generic;
using System.Configuration;
using System.Configuration.Provider;
using System.Web.Configuration;
using System.Web;
using ITViet.Domains;
using ITViet.Data;
using ITViet.Data.Bases;

#endregion

namespace ITViet.Data
{
	/// <summary>
	/// This class represents the Data source repository and gives access to all the underlying providers.
	/// </summary>
	[CLSCompliant(true)]
	public sealed class DataRepository 
	{
		private static volatile NetTiersProvider _provider = null;
        private static volatile NetTiersProviderCollection _providers = null;
		private static volatile NetTiersServiceSection _section = null;
		private static volatile Configuration _config = null;
        
        private static object SyncRoot = new object();
				
		private DataRepository()
		{
		}
		
		#region Public LoadProvider
		/// <summary>
        /// Enables the DataRepository to programatically create and 
        /// pass in a <c>NetTiersProvider</c> during runtime.
        /// </summary>
        /// <param name="provider">An instatiated NetTiersProvider.</param>
        public static void LoadProvider(NetTiersProvider provider)
        {
			LoadProvider(provider, false);
        }
		
		/// <summary>
        /// Enables the DataRepository to programatically create and 
        /// pass in a <c>NetTiersProvider</c> during runtime.
        /// </summary>
        /// <param name="provider">An instatiated NetTiersProvider.</param>
        /// <param name="setAsDefault">ability to set any valid provider as the default provider for the DataRepository.</param>
		public static void LoadProvider(NetTiersProvider provider, bool setAsDefault)
        {
            if (provider == null)
                throw new ArgumentNullException("provider");

            if (_providers == null)
			{
				lock(SyncRoot)
				{
            		if (_providers == null)
						_providers = new NetTiersProviderCollection();
				}
			}
			
            if (_providers[provider.Name] == null)
            {
                lock (_providers.SyncRoot)
                {
                    _providers.Add(provider);
                }
            }

            if (_provider == null || setAsDefault)
            {
                lock (SyncRoot)
                {
                    if(_provider == null || setAsDefault)
                         _provider = provider;
                }
            }
        }
		#endregion 
		
		///<summary>
		/// Configuration based provider loading, will load the providers on first call.
		///</summary>
		private static void LoadProviders()
        {
            // Avoid claiming lock if providers are already loaded
            if (_provider == null)
            {
                lock (SyncRoot)
                {
                    // Do this again to make sure _provider is still null
                    if (_provider == null)
                    {
                        // Load registered providers and point _provider to the default provider
                        _providers = new NetTiersProviderCollection();

                        ProvidersHelper.InstantiateProviders(NetTiersSection.Providers, _providers, typeof(NetTiersProvider));
						_provider = _providers[NetTiersSection.DefaultProvider];

                        if (_provider == null)
                        {
                            throw new ProviderException("Unable to load default NetTiersProvider");
                        }
                    }
                }
            }
        }

		/// <summary>
        /// Gets the provider.
        /// </summary>
        /// <value>The provider.</value>
        public static NetTiersProvider Provider
        {
            get { LoadProviders(); return _provider; }
        }

		/// <summary>
        /// Gets the provider collection.
        /// </summary>
        /// <value>The providers.</value>
        public static NetTiersProviderCollection Providers
        {
            get { LoadProviders(); return _providers; }
        }
		
		/// <summary>
		/// Creates a new <c cref="TransactionManager"/> instance from the current datasource.
		/// </summary>
		/// <returns></returns>
		public TransactionManager CreateTransaction()
		{
			return _provider.CreateTransaction();
		}

		#region Configuration

		/// <summary>
		/// Gets a reference to the configured NetTiersServiceSection object.
		/// </summary>
		public static NetTiersServiceSection NetTiersSection
		{
			get
			{
				// Try to get a reference to the default <netTiersService> section
				_section = WebConfigurationManager.GetSection("netTiersService") as NetTiersServiceSection;

				if ( _section == null )
				{
					// otherwise look for section based on the assembly name
					_section = WebConfigurationManager.GetSection("ITViet.Data") as NetTiersServiceSection;
				}

				#region Design-Time Support

				if ( _section == null )
				{
					// lastly, try to find the specific NetTiersServiceSection for this assembly
					foreach ( ConfigurationSection temp in Configuration.Sections )
					{
						if ( temp is NetTiersServiceSection )
						{
							_section = temp as NetTiersServiceSection;
							break;
						}
					}
				}

				#endregion Design-Time Support
				
				if ( _section == null )
				{
					throw new ProviderException("Unable to load NetTiersServiceSection");
				}

				return _section;
			}
		}

		#region Design-Time Support

		/// <summary>
		/// Gets a reference to the application configuration object.
		/// </summary>
		public static Configuration Configuration
		{
			get
			{
				if ( _config == null )
				{
					// load specific config file
					if ( HttpContext.Current != null )
					{
						_config = WebConfigurationManager.OpenWebConfiguration("~");
					}
					else
					{
						String configFile = AppDomain.CurrentDomain.SetupInformation.ConfigurationFile.Replace(".config", "").Replace(".temp", "");

						// check for design mode
						if ( configFile.ToLower().Contains("devenv.exe") )
						{
							_config = GetDesignTimeConfig();
						}
						else
						{
							_config = ConfigurationManager.OpenExeConfiguration(configFile);
						}
					}
				}

				return _config;
			}
		}

		private static Configuration GetDesignTimeConfig()
		{
			ExeConfigurationFileMap configMap = null;
			Configuration config = null;
			String path = null;

			// Get an instance of the currently running Visual Studio IDE.
			EnvDTE80.DTE2 dte = (EnvDTE80.DTE2) System.Runtime.InteropServices.Marshal.GetActiveObject("VisualStudio.DTE.9.0");
			
			if ( dte != null )
			{
				dte.SuppressUI = true;

				EnvDTE.ProjectItem item = dte.Solution.FindProjectItem("web.config");
				if ( item != null )
				{
					if (!item.ContainingProject.FullName.ToLower().StartsWith("http:"))
               {
                  System.IO.FileInfo info = new System.IO.FileInfo(item.ContainingProject.FullName);
                  path = String.Format("{0}\\{1}", info.Directory.FullName, item.Name);
                  configMap = new ExeConfigurationFileMap();
                  configMap.ExeConfigFilename = path;
               }
               else
               {
                  configMap = new ExeConfigurationFileMap();
                  configMap.ExeConfigFilename = item.get_FileNames(0);
               }}

				/*
				Array projects = (Array) dte2.ActiveSolutionProjects;
				EnvDTE.Project project = (EnvDTE.Project) projects.GetValue(0);
				System.IO.FileInfo info;

				foreach ( EnvDTE.ProjectItem item in project.ProjectItems )
				{
					if ( String.Compare(item.Name, "web.config", true) == 0 )
					{
						info = new System.IO.FileInfo(project.FullName);
						path = String.Format("{0}\\{1}", info.Directory.FullName, item.Name);
						configMap = new ExeConfigurationFileMap();
						configMap.ExeConfigFilename = path;
						break;
					}
				}
				*/
			}

			config = ConfigurationManager.OpenMappedExeConfiguration(configMap, ConfigurationUserLevel.None);
			return config;
		}

		#endregion Design-Time Support

		#endregion Configuration

		#region Connections

		/// <summary>
		/// Gets a reference to the ConnectionStringSettings collection.
		/// </summary>
		public static ConnectionStringSettingsCollection ConnectionStrings
		{
			get
			{
				// use default ConnectionStrings if _section has already been discovered
				if ( _config == null && _section != null )
				{
					return WebConfigurationManager.ConnectionStrings;
				}
				
				return Configuration.ConnectionStrings.ConnectionStrings;
			}
		}

		// dictionary of connection providers
		private static Dictionary<String, ConnectionProvider> _connections;

		/// <summary>
		/// Gets the dictionary of connection providers.
		/// </summary>
		public static Dictionary<String, ConnectionProvider> Connections
		{
			get
			{
				if ( _connections == null )
				{
					lock (SyncRoot)
                	{
						if (_connections == null)
						{
							_connections = new Dictionary<String, ConnectionProvider>();
		
							// add a connection provider for each configured connection string
							foreach ( ConnectionStringSettings conn in ConnectionStrings )
							{
								_connections.Add(conn.Name, new ConnectionProvider(conn.Name, conn.ConnectionString));
							}
						}
					}
				}

				return _connections;
			}
		}

		/// <summary>
		/// Adds the specified connection string to the map of connection strings.
		/// </summary>
		/// <param name="connectionStringName">The connection string name.</param>
		/// <param name="connectionString">The provider specific connection information.</param>
		public static void AddConnection(String connectionStringName, String connectionString)
		{
			lock (SyncRoot)
            {
				Connections.Remove(connectionStringName);
				ConnectionProvider connection = new ConnectionProvider(connectionStringName, connectionString);
				Connections.Add(connectionStringName, connection);
			}
		}

		/// <summary>
		/// Provides ability to switch connection string at runtime.
		/// </summary>
		public sealed class ConnectionProvider
		{
			private NetTiersProvider _provider;
			private NetTiersProviderCollection _providers;
			private String _connectionStringName;
			private String _connectionString;


			/// <summary>
			/// Initializes a new instance of the ConnectionProvider class.
			/// </summary>
			/// <param name="connectionStringName">The connection string name.</param>
			/// <param name="connectionString">The provider specific connection information.</param>
			public ConnectionProvider(String connectionStringName, String connectionString)
			{
				_connectionString = connectionString;
				_connectionStringName = connectionStringName;
			}

			/// <summary>
			/// Gets the provider.
			/// </summary>
			public NetTiersProvider Provider
			{
				get { LoadProviders(); return _provider; }
			}

			/// <summary>
			/// Gets the provider collection.
			/// </summary>
			public NetTiersProviderCollection Providers
			{
				get { LoadProviders(); return _providers; }
			}

			/// <summary>
			/// Instantiates the configured providers based on the supplied connection string.
			/// </summary>
			private void LoadProviders()
			{
				DataRepository.LoadProviders();

				// Avoid claiming lock if providers are already loaded
				if ( _providers == null )
				{
					lock ( SyncRoot )
					{
						// Do this again to make sure _provider is still null
						if ( _providers == null )
						{
							// apply connection information to each provider
							for ( int i = 0; i < NetTiersSection.Providers.Count; i++ )
							{
								NetTiersSection.Providers[i].Parameters["connectionStringName"] = _connectionStringName;
								// remove previous connection string, if any
								NetTiersSection.Providers[i].Parameters.Remove("connectionString");

								if ( !String.IsNullOrEmpty(_connectionString) )
								{
									NetTiersSection.Providers[i].Parameters["connectionString"] = _connectionString;
								}
							}

							// Load registered providers and point _provider to the default provider
							_providers = new NetTiersProviderCollection();

							ProvidersHelper.InstantiateProviders(NetTiersSection.Providers, _providers, typeof(NetTiersProvider));
							_provider = _providers[NetTiersSection.DefaultProvider];
						}
					}
				}
			}
		}

		#endregion Connections

		#region Static properties
		
		#region AdvertiseLocaleProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="AdvertiseLocale"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static AdvertiseLocaleProviderBase AdvertiseLocaleProvider
		{
			get 
			{
				LoadProviders();
				return _provider.AdvertiseLocaleProvider;
			}
		}
		
		#endregion
		
		#region ProductCategoryProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="ProductCategory"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static ProductCategoryProviderBase ProductCategoryProvider
		{
			get 
			{
				LoadProviders();
				return _provider.ProductCategoryProvider;
			}
		}
		
		#endregion
		
		#region ProductProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Product"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static ProductProviderBase ProductProvider
		{
			get 
			{
				LoadProviders();
				return _provider.ProductProvider;
			}
		}
		
		#endregion
		
		#region ProCategoryLocaleProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="ProCategoryLocale"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static ProCategoryLocaleProviderBase ProCategoryLocaleProvider
		{
			get 
			{
				LoadProviders();
				return _provider.ProCategoryLocaleProvider;
			}
		}
		
		#endregion
		
		#region NewsCategoryProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="NewsCategory"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static NewsCategoryProviderBase NewsCategoryProvider
		{
			get 
			{
				LoadProviders();
				return _provider.NewsCategoryProvider;
			}
		}
		
		#endregion
		
		#region NewsLetterProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="NewsLetter"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static NewsLetterProviderBase NewsLetterProvider
		{
			get 
			{
				LoadProviders();
				return _provider.NewsLetterProvider;
			}
		}
		
		#endregion
		
		#region ProductLocaleProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="ProductLocale"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static ProductLocaleProviderBase ProductLocaleProvider
		{
			get 
			{
				LoadProviders();
				return _provider.ProductLocaleProvider;
			}
		}
		
		#endregion
		
		#region NewsCategoryLocaleProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="NewsCategoryLocale"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static NewsCategoryLocaleProviderBase NewsCategoryLocaleProvider
		{
			get 
			{
				LoadProviders();
				return _provider.NewsCategoryLocaleProvider;
			}
		}
		
		#endregion
		
		#region AlbumProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Album"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static AlbumProviderBase AlbumProvider
		{
			get 
			{
				LoadProviders();
				return _provider.AlbumProvider;
			}
		}
		
		#endregion
		
		#region SettingProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Setting"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static SettingProviderBase SettingProvider
		{
			get 
			{
				LoadProviders();
				return _provider.SettingProvider;
			}
		}
		
		#endregion
		
		#region SurveyProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Survey"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static SurveyProviderBase SurveyProvider
		{
			get 
			{
				LoadProviders();
				return _provider.SurveyProvider;
			}
		}
		
		#endregion
		
		#region UserProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="User"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static UserProviderBase UserProvider
		{
			get 
			{
				LoadProviders();
				return _provider.UserProvider;
			}
		}
		
		#endregion
		
		#region SubMenuProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="SubMenu"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static SubMenuProviderBase SubMenuProvider
		{
			get 
			{
				LoadProviders();
				return _provider.SubMenuProvider;
			}
		}
		
		#endregion
		
		#region ProductFeatureProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="ProductFeature"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static ProductFeatureProviderBase ProductFeatureProvider
		{
			get 
			{
				LoadProviders();
				return _provider.ProductFeatureProvider;
			}
		}
		
		#endregion
		
		#region SurveyDetailProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="SurveyDetail"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static SurveyDetailProviderBase SurveyDetailProvider
		{
			get 
			{
				LoadProviders();
				return _provider.SurveyDetailProvider;
			}
		}
		
		#endregion
		
		#region NewsProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="News"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static NewsProviderBase NewsProvider
		{
			get 
			{
				LoadProviders();
				return _provider.NewsProvider;
			}
		}
		
		#endregion
		
		#region SubMenuLocaleProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="SubMenuLocale"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static SubMenuLocaleProviderBase SubMenuLocaleProvider
		{
			get 
			{
				LoadProviders();
				return _provider.SubMenuLocaleProvider;
			}
		}
		
		#endregion
		
		#region CustomerOpinionProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="CustomerOpinion"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static CustomerOpinionProviderBase CustomerOpinionProvider
		{
			get 
			{
				LoadProviders();
				return _provider.CustomerOpinionProvider;
			}
		}
		
		#endregion
		
		#region GroupProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Group"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static GroupProviderBase GroupProvider
		{
			get 
			{
				LoadProviders();
				return _provider.GroupProvider;
			}
		}
		
		#endregion
		
		#region ContactInfoProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="ContactInfo"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static ContactInfoProviderBase ContactInfoProvider
		{
			get 
			{
				LoadProviders();
				return _provider.ContactInfoProvider;
			}
		}
		
		#endregion
		
		#region FeatureListProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="FeatureList"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static FeatureListProviderBase FeatureListProvider
		{
			get 
			{
				LoadProviders();
				return _provider.FeatureListProvider;
			}
		}
		
		#endregion
		
		#region MultimediaProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Multimedia"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static MultimediaProviderBase MultimediaProvider
		{
			get 
			{
				LoadProviders();
				return _provider.MultimediaProvider;
			}
		}
		
		#endregion
		
		#region AlbumLocaleProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="AlbumLocale"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static AlbumLocaleProviderBase AlbumLocaleProvider
		{
			get 
			{
				LoadProviders();
				return _provider.AlbumLocaleProvider;
			}
		}
		
		#endregion
		
		#region FeatureListLocaleProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="FeatureListLocale"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static FeatureListLocaleProviderBase FeatureListLocaleProvider
		{
			get 
			{
				LoadProviders();
				return _provider.FeatureListLocaleProvider;
			}
		}
		
		#endregion
		
		#region AdvertisementProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Advertisement"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static AdvertisementProviderBase AdvertisementProvider
		{
			get 
			{
				LoadProviders();
				return _provider.AdvertisementProvider;
			}
		}
		
		#endregion
		
		#region FunctionProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Function"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static FunctionProviderBase FunctionProvider
		{
			get 
			{
				LoadProviders();
				return _provider.FunctionProvider;
			}
		}
		
		#endregion
		
		#region UserGroupProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="UserGroup"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static UserGroupProviderBase UserGroupProvider
		{
			get 
			{
				LoadProviders();
				return _provider.UserGroupProvider;
			}
		}
		
		#endregion
		
		#region MainMenuProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="MainMenu"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static MainMenuProviderBase MainMenuProvider
		{
			get 
			{
				LoadProviders();
				return _provider.MainMenuProvider;
			}
		}
		
		#endregion
		
		#region LanguageProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Language"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static LanguageProviderBase LanguageProvider
		{
			get 
			{
				LoadProviders();
				return _provider.LanguageProvider;
			}
		}
		
		#endregion
		
		#region MainMenuLocaleProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="MainMenuLocale"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static MainMenuLocaleProviderBase MainMenuLocaleProvider
		{
			get 
			{
				LoadProviders();
				return _provider.MainMenuLocaleProvider;
			}
		}
		
		#endregion
		
		#region HtmlContentProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="HtmlContent"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static HtmlContentProviderBase HtmlContentProvider
		{
			get 
			{
				LoadProviders();
				return _provider.HtmlContentProvider;
			}
		}
		
		#endregion
		
		#region MenuTypeProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="MenuType"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static MenuTypeProviderBase MenuTypeProvider
		{
			get 
			{
				LoadProviders();
				return _provider.MenuTypeProvider;
			}
		}
		
		#endregion
		
		#region GroupPermissionProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="GroupPermission"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static GroupPermissionProviderBase GroupPermissionProvider
		{
			get 
			{
				LoadProviders();
				return _provider.GroupPermissionProvider;
			}
		}
		
		#endregion
		
		
		#endregion
	}
	
	#region Query/Filters
		
	#region AdvertiseLocaleFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="AdvertiseLocale"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class AdvertiseLocaleFilters : AdvertiseLocaleFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the AdvertiseLocaleFilters class.
		/// </summary>
		public AdvertiseLocaleFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the AdvertiseLocaleFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public AdvertiseLocaleFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the AdvertiseLocaleFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public AdvertiseLocaleFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion AdvertiseLocaleFilters
	
	#region AdvertiseLocaleQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="AdvertiseLocaleParameterBuilder"/> class
	/// that is used exclusively with a <see cref="AdvertiseLocale"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class AdvertiseLocaleQuery : AdvertiseLocaleParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the AdvertiseLocaleQuery class.
		/// </summary>
		public AdvertiseLocaleQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the AdvertiseLocaleQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public AdvertiseLocaleQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the AdvertiseLocaleQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public AdvertiseLocaleQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion AdvertiseLocaleQuery
		
	#region ProductCategoryFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="ProductCategory"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ProductCategoryFilters : ProductCategoryFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ProductCategoryFilters class.
		/// </summary>
		public ProductCategoryFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the ProductCategoryFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ProductCategoryFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ProductCategoryFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ProductCategoryFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ProductCategoryFilters
	
	#region ProductCategoryQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="ProductCategoryParameterBuilder"/> class
	/// that is used exclusively with a <see cref="ProductCategory"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ProductCategoryQuery : ProductCategoryParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ProductCategoryQuery class.
		/// </summary>
		public ProductCategoryQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the ProductCategoryQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ProductCategoryQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ProductCategoryQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ProductCategoryQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ProductCategoryQuery
		
	#region ProductFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Product"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ProductFilters : ProductFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ProductFilters class.
		/// </summary>
		public ProductFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the ProductFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ProductFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ProductFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ProductFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ProductFilters
	
	#region ProductQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="ProductParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Product"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ProductQuery : ProductParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ProductQuery class.
		/// </summary>
		public ProductQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the ProductQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ProductQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ProductQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ProductQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ProductQuery
		
	#region ProCategoryLocaleFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="ProCategoryLocale"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ProCategoryLocaleFilters : ProCategoryLocaleFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ProCategoryLocaleFilters class.
		/// </summary>
		public ProCategoryLocaleFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the ProCategoryLocaleFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ProCategoryLocaleFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ProCategoryLocaleFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ProCategoryLocaleFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ProCategoryLocaleFilters
	
	#region ProCategoryLocaleQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="ProCategoryLocaleParameterBuilder"/> class
	/// that is used exclusively with a <see cref="ProCategoryLocale"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ProCategoryLocaleQuery : ProCategoryLocaleParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ProCategoryLocaleQuery class.
		/// </summary>
		public ProCategoryLocaleQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the ProCategoryLocaleQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ProCategoryLocaleQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ProCategoryLocaleQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ProCategoryLocaleQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ProCategoryLocaleQuery
		
	#region NewsCategoryFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="NewsCategory"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class NewsCategoryFilters : NewsCategoryFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the NewsCategoryFilters class.
		/// </summary>
		public NewsCategoryFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the NewsCategoryFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public NewsCategoryFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the NewsCategoryFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public NewsCategoryFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion NewsCategoryFilters
	
	#region NewsCategoryQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="NewsCategoryParameterBuilder"/> class
	/// that is used exclusively with a <see cref="NewsCategory"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class NewsCategoryQuery : NewsCategoryParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the NewsCategoryQuery class.
		/// </summary>
		public NewsCategoryQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the NewsCategoryQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public NewsCategoryQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the NewsCategoryQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public NewsCategoryQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion NewsCategoryQuery
		
	#region NewsLetterFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="NewsLetter"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class NewsLetterFilters : NewsLetterFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the NewsLetterFilters class.
		/// </summary>
		public NewsLetterFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the NewsLetterFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public NewsLetterFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the NewsLetterFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public NewsLetterFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion NewsLetterFilters
	
	#region NewsLetterQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="NewsLetterParameterBuilder"/> class
	/// that is used exclusively with a <see cref="NewsLetter"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class NewsLetterQuery : NewsLetterParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the NewsLetterQuery class.
		/// </summary>
		public NewsLetterQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the NewsLetterQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public NewsLetterQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the NewsLetterQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public NewsLetterQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion NewsLetterQuery
		
	#region ProductLocaleFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="ProductLocale"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ProductLocaleFilters : ProductLocaleFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ProductLocaleFilters class.
		/// </summary>
		public ProductLocaleFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the ProductLocaleFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ProductLocaleFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ProductLocaleFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ProductLocaleFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ProductLocaleFilters
	
	#region ProductLocaleQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="ProductLocaleParameterBuilder"/> class
	/// that is used exclusively with a <see cref="ProductLocale"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ProductLocaleQuery : ProductLocaleParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ProductLocaleQuery class.
		/// </summary>
		public ProductLocaleQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the ProductLocaleQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ProductLocaleQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ProductLocaleQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ProductLocaleQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ProductLocaleQuery
		
	#region NewsCategoryLocaleFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="NewsCategoryLocale"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class NewsCategoryLocaleFilters : NewsCategoryLocaleFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the NewsCategoryLocaleFilters class.
		/// </summary>
		public NewsCategoryLocaleFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the NewsCategoryLocaleFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public NewsCategoryLocaleFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the NewsCategoryLocaleFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public NewsCategoryLocaleFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion NewsCategoryLocaleFilters
	
	#region NewsCategoryLocaleQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="NewsCategoryLocaleParameterBuilder"/> class
	/// that is used exclusively with a <see cref="NewsCategoryLocale"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class NewsCategoryLocaleQuery : NewsCategoryLocaleParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the NewsCategoryLocaleQuery class.
		/// </summary>
		public NewsCategoryLocaleQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the NewsCategoryLocaleQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public NewsCategoryLocaleQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the NewsCategoryLocaleQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public NewsCategoryLocaleQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion NewsCategoryLocaleQuery
		
	#region AlbumFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Album"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class AlbumFilters : AlbumFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the AlbumFilters class.
		/// </summary>
		public AlbumFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the AlbumFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public AlbumFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the AlbumFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public AlbumFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion AlbumFilters
	
	#region AlbumQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="AlbumParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Album"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class AlbumQuery : AlbumParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the AlbumQuery class.
		/// </summary>
		public AlbumQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the AlbumQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public AlbumQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the AlbumQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public AlbumQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion AlbumQuery
		
	#region SettingFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Setting"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SettingFilters : SettingFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SettingFilters class.
		/// </summary>
		public SettingFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the SettingFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SettingFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SettingFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SettingFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SettingFilters
	
	#region SettingQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SettingParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Setting"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SettingQuery : SettingParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SettingQuery class.
		/// </summary>
		public SettingQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the SettingQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SettingQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SettingQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SettingQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SettingQuery
		
	#region SurveyFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Survey"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SurveyFilters : SurveyFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SurveyFilters class.
		/// </summary>
		public SurveyFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the SurveyFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SurveyFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SurveyFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SurveyFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SurveyFilters
	
	#region SurveyQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SurveyParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Survey"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SurveyQuery : SurveyParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SurveyQuery class.
		/// </summary>
		public SurveyQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the SurveyQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SurveyQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SurveyQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SurveyQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SurveyQuery
		
	#region UserFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="User"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class UserFilters : UserFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the UserFilters class.
		/// </summary>
		public UserFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the UserFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public UserFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the UserFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public UserFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion UserFilters
	
	#region UserQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="UserParameterBuilder"/> class
	/// that is used exclusively with a <see cref="User"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class UserQuery : UserParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the UserQuery class.
		/// </summary>
		public UserQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the UserQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public UserQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the UserQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public UserQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion UserQuery
		
	#region SubMenuFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="SubMenu"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SubMenuFilters : SubMenuFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SubMenuFilters class.
		/// </summary>
		public SubMenuFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the SubMenuFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SubMenuFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SubMenuFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SubMenuFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SubMenuFilters
	
	#region SubMenuQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SubMenuParameterBuilder"/> class
	/// that is used exclusively with a <see cref="SubMenu"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SubMenuQuery : SubMenuParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SubMenuQuery class.
		/// </summary>
		public SubMenuQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the SubMenuQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SubMenuQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SubMenuQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SubMenuQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SubMenuQuery
		
	#region ProductFeatureFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="ProductFeature"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ProductFeatureFilters : ProductFeatureFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ProductFeatureFilters class.
		/// </summary>
		public ProductFeatureFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the ProductFeatureFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ProductFeatureFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ProductFeatureFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ProductFeatureFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ProductFeatureFilters
	
	#region ProductFeatureQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="ProductFeatureParameterBuilder"/> class
	/// that is used exclusively with a <see cref="ProductFeature"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ProductFeatureQuery : ProductFeatureParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ProductFeatureQuery class.
		/// </summary>
		public ProductFeatureQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the ProductFeatureQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ProductFeatureQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ProductFeatureQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ProductFeatureQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ProductFeatureQuery
		
	#region SurveyDetailFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="SurveyDetail"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SurveyDetailFilters : SurveyDetailFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SurveyDetailFilters class.
		/// </summary>
		public SurveyDetailFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the SurveyDetailFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SurveyDetailFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SurveyDetailFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SurveyDetailFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SurveyDetailFilters
	
	#region SurveyDetailQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SurveyDetailParameterBuilder"/> class
	/// that is used exclusively with a <see cref="SurveyDetail"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SurveyDetailQuery : SurveyDetailParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SurveyDetailQuery class.
		/// </summary>
		public SurveyDetailQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the SurveyDetailQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SurveyDetailQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SurveyDetailQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SurveyDetailQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SurveyDetailQuery
		
	#region NewsFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="News"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class NewsFilters : NewsFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the NewsFilters class.
		/// </summary>
		public NewsFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the NewsFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public NewsFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the NewsFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public NewsFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion NewsFilters
	
	#region NewsQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="NewsParameterBuilder"/> class
	/// that is used exclusively with a <see cref="News"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class NewsQuery : NewsParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the NewsQuery class.
		/// </summary>
		public NewsQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the NewsQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public NewsQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the NewsQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public NewsQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion NewsQuery
		
	#region SubMenuLocaleFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="SubMenuLocale"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SubMenuLocaleFilters : SubMenuLocaleFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SubMenuLocaleFilters class.
		/// </summary>
		public SubMenuLocaleFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the SubMenuLocaleFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SubMenuLocaleFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SubMenuLocaleFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SubMenuLocaleFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SubMenuLocaleFilters
	
	#region SubMenuLocaleQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SubMenuLocaleParameterBuilder"/> class
	/// that is used exclusively with a <see cref="SubMenuLocale"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SubMenuLocaleQuery : SubMenuLocaleParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SubMenuLocaleQuery class.
		/// </summary>
		public SubMenuLocaleQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the SubMenuLocaleQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SubMenuLocaleQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SubMenuLocaleQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SubMenuLocaleQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SubMenuLocaleQuery
		
	#region CustomerOpinionFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="CustomerOpinion"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class CustomerOpinionFilters : CustomerOpinionFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the CustomerOpinionFilters class.
		/// </summary>
		public CustomerOpinionFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the CustomerOpinionFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public CustomerOpinionFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the CustomerOpinionFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public CustomerOpinionFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion CustomerOpinionFilters
	
	#region CustomerOpinionQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="CustomerOpinionParameterBuilder"/> class
	/// that is used exclusively with a <see cref="CustomerOpinion"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class CustomerOpinionQuery : CustomerOpinionParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the CustomerOpinionQuery class.
		/// </summary>
		public CustomerOpinionQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the CustomerOpinionQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public CustomerOpinionQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the CustomerOpinionQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public CustomerOpinionQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion CustomerOpinionQuery
		
	#region GroupFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Group"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class GroupFilters : GroupFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the GroupFilters class.
		/// </summary>
		public GroupFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the GroupFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public GroupFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the GroupFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public GroupFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion GroupFilters
	
	#region GroupQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="GroupParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Group"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class GroupQuery : GroupParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the GroupQuery class.
		/// </summary>
		public GroupQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the GroupQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public GroupQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the GroupQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public GroupQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion GroupQuery
		
	#region ContactInfoFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="ContactInfo"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ContactInfoFilters : ContactInfoFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ContactInfoFilters class.
		/// </summary>
		public ContactInfoFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the ContactInfoFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ContactInfoFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ContactInfoFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ContactInfoFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ContactInfoFilters
	
	#region ContactInfoQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="ContactInfoParameterBuilder"/> class
	/// that is used exclusively with a <see cref="ContactInfo"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ContactInfoQuery : ContactInfoParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ContactInfoQuery class.
		/// </summary>
		public ContactInfoQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the ContactInfoQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ContactInfoQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ContactInfoQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ContactInfoQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ContactInfoQuery
		
	#region FeatureListFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="FeatureList"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class FeatureListFilters : FeatureListFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the FeatureListFilters class.
		/// </summary>
		public FeatureListFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the FeatureListFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public FeatureListFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the FeatureListFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public FeatureListFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion FeatureListFilters
	
	#region FeatureListQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="FeatureListParameterBuilder"/> class
	/// that is used exclusively with a <see cref="FeatureList"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class FeatureListQuery : FeatureListParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the FeatureListQuery class.
		/// </summary>
		public FeatureListQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the FeatureListQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public FeatureListQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the FeatureListQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public FeatureListQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion FeatureListQuery
		
	#region MultimediaFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Multimedia"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class MultimediaFilters : MultimediaFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the MultimediaFilters class.
		/// </summary>
		public MultimediaFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the MultimediaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public MultimediaFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the MultimediaFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public MultimediaFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion MultimediaFilters
	
	#region MultimediaQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="MultimediaParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Multimedia"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class MultimediaQuery : MultimediaParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the MultimediaQuery class.
		/// </summary>
		public MultimediaQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the MultimediaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public MultimediaQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the MultimediaQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public MultimediaQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion MultimediaQuery
		
	#region AlbumLocaleFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="AlbumLocale"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class AlbumLocaleFilters : AlbumLocaleFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the AlbumLocaleFilters class.
		/// </summary>
		public AlbumLocaleFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the AlbumLocaleFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public AlbumLocaleFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the AlbumLocaleFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public AlbumLocaleFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion AlbumLocaleFilters
	
	#region AlbumLocaleQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="AlbumLocaleParameterBuilder"/> class
	/// that is used exclusively with a <see cref="AlbumLocale"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class AlbumLocaleQuery : AlbumLocaleParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the AlbumLocaleQuery class.
		/// </summary>
		public AlbumLocaleQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the AlbumLocaleQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public AlbumLocaleQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the AlbumLocaleQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public AlbumLocaleQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion AlbumLocaleQuery
		
	#region FeatureListLocaleFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="FeatureListLocale"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class FeatureListLocaleFilters : FeatureListLocaleFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the FeatureListLocaleFilters class.
		/// </summary>
		public FeatureListLocaleFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the FeatureListLocaleFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public FeatureListLocaleFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the FeatureListLocaleFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public FeatureListLocaleFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion FeatureListLocaleFilters
	
	#region FeatureListLocaleQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="FeatureListLocaleParameterBuilder"/> class
	/// that is used exclusively with a <see cref="FeatureListLocale"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class FeatureListLocaleQuery : FeatureListLocaleParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the FeatureListLocaleQuery class.
		/// </summary>
		public FeatureListLocaleQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the FeatureListLocaleQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public FeatureListLocaleQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the FeatureListLocaleQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public FeatureListLocaleQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion FeatureListLocaleQuery
		
	#region AdvertisementFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Advertisement"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class AdvertisementFilters : AdvertisementFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the AdvertisementFilters class.
		/// </summary>
		public AdvertisementFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the AdvertisementFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public AdvertisementFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the AdvertisementFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public AdvertisementFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion AdvertisementFilters
	
	#region AdvertisementQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="AdvertisementParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Advertisement"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class AdvertisementQuery : AdvertisementParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the AdvertisementQuery class.
		/// </summary>
		public AdvertisementQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the AdvertisementQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public AdvertisementQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the AdvertisementQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public AdvertisementQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion AdvertisementQuery
		
	#region FunctionFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Function"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class FunctionFilters : FunctionFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the FunctionFilters class.
		/// </summary>
		public FunctionFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the FunctionFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public FunctionFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the FunctionFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public FunctionFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion FunctionFilters
	
	#region FunctionQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="FunctionParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Function"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class FunctionQuery : FunctionParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the FunctionQuery class.
		/// </summary>
		public FunctionQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the FunctionQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public FunctionQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the FunctionQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public FunctionQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion FunctionQuery
		
	#region UserGroupFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="UserGroup"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class UserGroupFilters : UserGroupFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the UserGroupFilters class.
		/// </summary>
		public UserGroupFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the UserGroupFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public UserGroupFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the UserGroupFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public UserGroupFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion UserGroupFilters
	
	#region UserGroupQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="UserGroupParameterBuilder"/> class
	/// that is used exclusively with a <see cref="UserGroup"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class UserGroupQuery : UserGroupParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the UserGroupQuery class.
		/// </summary>
		public UserGroupQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the UserGroupQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public UserGroupQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the UserGroupQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public UserGroupQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion UserGroupQuery
		
	#region MainMenuFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="MainMenu"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class MainMenuFilters : MainMenuFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the MainMenuFilters class.
		/// </summary>
		public MainMenuFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the MainMenuFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public MainMenuFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the MainMenuFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public MainMenuFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion MainMenuFilters
	
	#region MainMenuQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="MainMenuParameterBuilder"/> class
	/// that is used exclusively with a <see cref="MainMenu"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class MainMenuQuery : MainMenuParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the MainMenuQuery class.
		/// </summary>
		public MainMenuQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the MainMenuQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public MainMenuQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the MainMenuQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public MainMenuQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion MainMenuQuery
		
	#region LanguageFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Language"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class LanguageFilters : LanguageFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the LanguageFilters class.
		/// </summary>
		public LanguageFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the LanguageFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public LanguageFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the LanguageFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public LanguageFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion LanguageFilters
	
	#region LanguageQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="LanguageParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Language"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class LanguageQuery : LanguageParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the LanguageQuery class.
		/// </summary>
		public LanguageQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the LanguageQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public LanguageQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the LanguageQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public LanguageQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion LanguageQuery
		
	#region MainMenuLocaleFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="MainMenuLocale"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class MainMenuLocaleFilters : MainMenuLocaleFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the MainMenuLocaleFilters class.
		/// </summary>
		public MainMenuLocaleFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the MainMenuLocaleFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public MainMenuLocaleFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the MainMenuLocaleFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public MainMenuLocaleFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion MainMenuLocaleFilters
	
	#region MainMenuLocaleQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="MainMenuLocaleParameterBuilder"/> class
	/// that is used exclusively with a <see cref="MainMenuLocale"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class MainMenuLocaleQuery : MainMenuLocaleParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the MainMenuLocaleQuery class.
		/// </summary>
		public MainMenuLocaleQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the MainMenuLocaleQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public MainMenuLocaleQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the MainMenuLocaleQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public MainMenuLocaleQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion MainMenuLocaleQuery
		
	#region HtmlContentFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="HtmlContent"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class HtmlContentFilters : HtmlContentFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the HtmlContentFilters class.
		/// </summary>
		public HtmlContentFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the HtmlContentFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public HtmlContentFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the HtmlContentFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public HtmlContentFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion HtmlContentFilters
	
	#region HtmlContentQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="HtmlContentParameterBuilder"/> class
	/// that is used exclusively with a <see cref="HtmlContent"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class HtmlContentQuery : HtmlContentParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the HtmlContentQuery class.
		/// </summary>
		public HtmlContentQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the HtmlContentQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public HtmlContentQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the HtmlContentQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public HtmlContentQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion HtmlContentQuery
		
	#region MenuTypeFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="MenuType"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class MenuTypeFilters : MenuTypeFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the MenuTypeFilters class.
		/// </summary>
		public MenuTypeFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the MenuTypeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public MenuTypeFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the MenuTypeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public MenuTypeFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion MenuTypeFilters
	
	#region MenuTypeQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="MenuTypeParameterBuilder"/> class
	/// that is used exclusively with a <see cref="MenuType"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class MenuTypeQuery : MenuTypeParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the MenuTypeQuery class.
		/// </summary>
		public MenuTypeQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the MenuTypeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public MenuTypeQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the MenuTypeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public MenuTypeQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion MenuTypeQuery
		
	#region GroupPermissionFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="GroupPermission"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class GroupPermissionFilters : GroupPermissionFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the GroupPermissionFilters class.
		/// </summary>
		public GroupPermissionFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the GroupPermissionFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public GroupPermissionFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the GroupPermissionFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public GroupPermissionFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion GroupPermissionFilters
	
	#region GroupPermissionQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="GroupPermissionParameterBuilder"/> class
	/// that is used exclusively with a <see cref="GroupPermission"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class GroupPermissionQuery : GroupPermissionParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the GroupPermissionQuery class.
		/// </summary>
		public GroupPermissionQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the GroupPermissionQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public GroupPermissionQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the GroupPermissionQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public GroupPermissionQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion GroupPermissionQuery
	#endregion

	
}
